package com.example.qt.ptplatform.service;

import io.pinecone.clients.Index;
import org.json.JSONArray;
import org.json.JSONObject;
import org.openapitools.db_data.client.model.SearchRecordsResponse;
import org.openapitools.db_data.client.model.SearchRecordsVector;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;
import org.springframework.http.*;
import io.pinecone.clients.Pinecone;
import org.openapitools.db_data.client.ApiException;

import java.util.*;

@Service
public class AiAssistantService {

    private final Pinecone pinecone;

    private final PineconeService pineconeService;

    @Autowired
    public AiAssistantService(Pinecone pinecone, PineconeService pineconeService) {
        this.pinecone = pinecone;
        this.pineconeService = pineconeService;
    }

    @Value("${zhipuai.api-key}")
    private String apiKey;  // 从配置文件中注入 API 密钥

    private final String apiUrl = "https://open.bigmodel.cn/api/paas/v4/chat/completions";  // API 地址
    private final RestTemplate restTemplate = new RestTemplate();

    public String getAssistantResponse(String userMessage) {

        String addpromote = getRelevantAnswer(userMessage);

        System.out.println(addpromote);

        JSONObject requestBody = new JSONObject();

        // 模型选择
        requestBody.put("model", "glm-4-flashx");  // 选择您要调用的模型

        // 是否进行采样
        requestBody.put("do_sample", true);
        requestBody.put("stream", false);

        // 消息列表，包含 system 和 user 角色的消息
        JSONArray messages = new JSONArray();

        // System 角色消息，告知模型它需要根据传入的对话内容生成自然语言回答
        JSONObject systemMessage = new JSONObject();
        systemMessage.put("role", "system");
        systemMessage.put("content", "你是一个pt站的ai小助手，主要目的是为了帮助用户更好的使用我们的pt站,我们的pt站的名字叫做'北交人。" +
                "你能够根据用户提供的对话内容生成回答,请在回答中融合这些知识点（如果有用的话就融入，太牵强的也不用非要融入，注意，涉及到功能性的话就根据这些知识点，不要乱补充知识点）:"+addpromote+
                "此外,可以适当进行扩句润色回答。如果用户提问与pt站无关的内容，那么在回答之后可以引导用户提问有关本pt站的内容;" +
                "如果提问与pt站有关，就不用引导了，回答问题就行。");
        messages.put(systemMessage);

        // User 角色消息，传入用户的动态提问（即传递的 userMessage 参数）
        JSONObject userMessageObj = new JSONObject();
        userMessageObj.put("role", "user");
        userMessageObj.put("content", userMessage);  // 用户提供的消息
        messages.put(userMessageObj);

        requestBody.put("messages", messages);

        // 设置请求头，包含 API Key
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON);
        headers.set("Authorization", "Bearer " + apiKey);

        // 创建 HTTP 请求实体
        HttpEntity<String> entity = new HttpEntity<>(requestBody.toString(), headers);

        // 发送 POST 请求
        ResponseEntity<String> response = restTemplate.exchange(
                apiUrl,
                HttpMethod.POST,
                entity,
                String.class
        );

        // 解析返回的 JSON 响应
        JSONObject jsonResponse = new JSONObject(response.getBody());

        // 返回生成的内容（即 AI 的结构化摘要或自然语言回答）
        return jsonResponse.getJSONArray("choices").getJSONObject(0).getJSONObject("message").getString("content");
    }


    public String getRelevantAnswer(String text) {
        try {

            JSONObject jsonObject = new JSONObject(text);
            String userMessage = jsonObject.getString("userMessage");
            System.out.println(userMessage);

            String indexName = "aiassistant";  // 这里是您在 Pinecone 上使用的索引名称
            String namespace = "__default__";  // 可以根据需要调整命名空间

            // 获取 Pinecone 索引连接
            Index index = pinecone.getIndexConnection(indexName);

            // 对用户消息进行向量化
            float[] vectorArray = pineconeService.vectorizeText(userMessage);

            // 转换为 List<Float> 类型
            List<Float> queryVector = new ArrayList<>();
            for (float val : vectorArray) {
                queryVector.add(val);
            }

            // 创建查询向量对象
            SearchRecordsVector searchVector = new SearchRecordsVector()
                    .values(queryVector);  // 设置向量值

            // 执行查询，确保返回 metadata 字段
            SearchRecordsResponse response = index.searchRecordsByVector(
                    searchVector,
                    namespace,
                    null,  // 改为 null 或 Collections.emptyList() 以返回所有字段
                    1,  // 返回最相关的两条数据
                    null,  // 过滤条件
                    null   // 重排参数
            );



            // 检查响应中的 hits 数组
            if (response.getResult().getHits().isEmpty()) {
                System.out.println("No matches found!");
                return null;  // 如果没有匹配，返回 null
            } else {
                System.out.println("Matches found: " + response.getResult().getHits().size());
            }

            System.out.println("反馈如下:" + response);


            // 打印每个 hit 的 metadata 字段
            for (int i = 0; i < response.getResult().getHits().size(); i++) {
                Map<String, Object> metadata = (Map<String, Object>) response.getResult().getHits().get(i).getFields();
                System.out.println("Hit " + i + " metadata: " + metadata);  // 打印 metadata 字段
            }

            // 创建 StringBuilder 来存储结果
            StringBuilder result = new StringBuilder();

            // 遍历 hits 数组，提取每个记录的答案
            for (int i = 0; i < response.getResult().getHits().size(); i++) {
                // 获取 metadata (它是一个 Map<String, Object>)
                Map<String, Object> metadata = (Map<String, Object>) response.getResult().getHits().get(i).getFields();  // 强制转换为 Map 类型

                // 从 metadata 中获取 "answer" 字段的值
                String answer = (String) metadata.get("answer");  // 获取 "answer" 字段的值
                if (answer != null) {
                    result.append(answer);  // 添加答案到结果
                }
            }

            // 返回最终拼接的答案
            return result.toString();

        } catch (ApiException e) {
            // 处理 API 异常
            System.err.println("Pinecone API 异常: " + e.getMessage());
            e.printStackTrace();
        }
        return null;
    }
}



